home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / util / misc / Fudgit233.lha / Source / src / install.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-14  |  5.1 KB  |  219 lines
  1. /****************************
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. #include "fudgit.h"
  6. #include "symbol.h"
  7. #include "command.h"
  8. #include "code.h"
  9. #include "math.tab.h"
  10. *******************************/
  11.  
  12. #if defined(sgi)
  13. #include "dl/dl.h"
  14. #include <symconst.h>
  15. #else
  16. #include "dld/dl/dl.h"
  17. #define stProc 1
  18. #endif
  19.  
  20. typedef double (*dblfunc) ();
  21.  
  22. #ifndef NOSTDLIB_H
  23. #include <stdlib.h>
  24. #endif
  25.  
  26. static int do_install(int argc, char **argv, char *l, Command *cmd)
  27. {
  28.     Symbol *sym[MATHMAXFUNC];
  29.     extern char *Ft_Progname;
  30.     char *locp, *vp, *cp, *tvec;
  31.     char varname[MAXVARNAME];
  32.     int types[MATHMAXFUNC];
  33.     struct nlist rtnes[MATHMAXFUNC];
  34.     int vtype, argno;
  35.     extern int Ft_varcpy(char *, char *);
  36.     int func, rti, retval = 0;
  37.  
  38.     if (argc < 4 || argc%2)
  39.         return(usage(cmd));
  40.     if (argc > MATHMAXFUNC + 2) {
  41.         fprintf(stderr, "%s: Too many functions.\n", cmd->fname);
  42.         return(ERRR);
  43.     }
  44.     for (func=2,rti=0; func<argc; func+=2,rti++) {
  45.         locp = argv[func];
  46.         while (*locp && *locp != ':' && *locp != '=')
  47.             locp++;
  48.         if (!locp[0] || !locp[1]) {
  49.             fprintf(stderr, "%s: Argument `%s' garbled.\n", cmd->fname,
  50.             argv[func]);
  51.             return(usage(cmd));
  52.         }
  53.         switch(*locp) {
  54.             case ':':
  55.                 types[rti] = EPROCSYM;
  56.                 break;
  57.             case '=':
  58.                 types[rti] = EFUNCSYM;
  59.                 break;
  60.             default:
  61.                 fprintf(stderr, "%s: Should never be here.\n", cmd->fname);
  62.                 return(usage(cmd));
  63.         }
  64.         *locp++ = '\0'; /* this now points to the local routine name */
  65.         if (Ft_varcpy(0, locp) != VAR) {  /* check type */
  66.             fprintf(stderr, "%s: %s: Illegal name.\n", cmd->fname, locp);
  67.             return(ERRR);
  68.         }
  69.         if ((sym[rti] = Ft_lookup(locp)) == 0) {
  70.             sym[rti] = Ft_install(locp, UNDEFVAR, 1);
  71.             if ((sym[rti]->size.vals = (char *)calloc(MATHMAXARG+1,
  72.             sizeof(char))) == (char *)NULL) {
  73.                 fprintf(stderr, "%s: Allocation error.\n", cmd->fname);
  74.                 return(ERRR);
  75.             }
  76.         }
  77.         else if (sym[rti]->type != types[rti] && sym[rti]->type != UNDEFVAR) {
  78.             fprintf(stderr,
  79.             "%s: %s: Already defined differently. (Must be freed first)\n",
  80.             cmd->fname, locp);
  81.             return(ERRR);
  82.         }
  83.         rtnes[rti].n_name = argv[func];
  84.         rtnes[rti].n_type = 0;
  85.         tvec = sym[rti]->size.vals;
  86.         cp = argv[func+1];
  87.         if (*cp != '(')
  88.             return(usage(cmd));
  89.         cp++;
  90.         for (argno = 0; ;argno++) {
  91.             if (argno >= MATHMAXARG) {
  92.                 fprintf(stderr,
  93.                 "%s: Too many arguments (%d).\n", cmd->fname, argno);
  94.                 return(ERRR);
  95.             }
  96.             while (*cp && (isspace(*cp) || *cp == ','))
  97.                 cp++;
  98.             if (!cp[0]) {
  99.                 fprintf(stderr, "%s: Garbled argument list `%s'.\n",
  100.                 cmd->fname, argv[func+1]);
  101.                 return(usage(cmd));
  102.             }
  103.             if (*cp == ')')
  104.                 break;
  105.             vp = varname;
  106.             while (*cp && *cp != ' ' && *cp != '\t' && *cp != ',' && *cp != ')')
  107.                 *vp++ = *cp++;
  108.             *vp = '\0';
  109.             vtype = Ft_varcpy(0, varname);
  110.             switch(vtype) {
  111.             case VAR:
  112.                 *tvec = PROTO_VAL;
  113.                 break;
  114.             case VEC:
  115.                 if (strcmp(varname, "P") == 0)
  116.                     *tvec = PROTO_PAR;
  117.                 else
  118.                     *tvec = PROTO_VEC;
  119.                 break;
  120.             case STRVAR:
  121.                 *tvec = PROTO_STR;
  122.                 break;
  123.             default:  /* defensive programming */
  124.                 fprintf(stderr, "%s: Impossible type in switch.\n", cmd->fname);
  125.                 return(ERRR);
  126.             }
  127.             tvec++;
  128.         }
  129.         *tvec-- = PROTO_END;
  130.         cp = sym[rti]->size.vals;
  131.         while (tvec > cp) {   /* invert order */
  132.             char ctmp;
  133.  
  134.             ctmp = *cp; *cp = *tvec; *tvec = ctmp;
  135.             tvec--; cp++;
  136.         }
  137.     }
  138.     rtnes[rti].n_name = (char *)NULL;
  139.     if (strcmp(cmd->fname, "reinstall") == 0) {
  140. #if defined(sun) || defined(sparc) || defined(ultrix)
  141.         dld_unlink_by_file(argv[1], 0);
  142. #else
  143.         ;
  144. #endif
  145.     }
  146.     func = dl_loadmod_mult(Ft_Progname, argv[1], rtnes);
  147.     if (rti != func) {
  148.         fprintf(stderr, "%s: %d symbol(s) not found.\n", cmd->fname,
  149.         (rti-func));
  150.         retval = ERRR;
  151.     }
  152.     for (rti=0;rtnes[rti].n_name != (char *)NULL;rti++) {
  153.         if (rtnes[rti].n_type) {
  154. /* 
  155.  * if your IRIX version is  != 4.0.5 => nlist returns stProc + 1 
  156.  * otherwise (if == 4.0.5) => nlist returns stProc
  157.  *
  158.  * Change the following line according to your OS version.
  159.  * For non-IRIX machines use stProc only.
  160.  */
  161. #if defined(sgi) && !defined(SAME_STPROC)
  162.             /*  IRIX != 4.0.5 */
  163.             if (rtnes[rti].n_type == stProc + 1) {
  164. #else
  165.             /* IRIX  == 4.0.5 and others (ULTRIX, SUNOS) */
  166.             if (rtnes[rti].n_type == stProc) {
  167. #endif
  168.                 sym[rti]->u.ptr = (dblfunc) rtnes[rti].n_value;
  169.                 sym[rti]->type = types[rti];
  170.                 fprintf(stderr, "%s: %s installed as %s %s.\n",
  171.                 cmd->fname, rtnes[rti].n_name, 
  172.                 (types[rti] == EPROCSYM ? "procedure" : "function"),
  173.                 sym[rti]->name);
  174.             }
  175.             else {
  176.                 fprintf(stderr, "%s: %s: Not a procedure (%d).\n", cmd->fname,
  177.                 rtnes[rti].n_name, rtnes[rti].n_type);
  178.                 retval = ERRR;
  179.             }
  180.         }
  181.         else {
  182.             fprintf(stderr, "%s: %s: No such symbol.\n", cmd->fname,
  183.             rtnes[rti].n_name);
  184.             retval = ERRR;
  185.         }
  186.         if (sym[rti]->type == UNDEFVAR)
  187.             free(sym[rti]->size.vals);
  188.     }
  189.  
  190.     return(retval);
  191. }
  192.  
  193. int Ft_initdl(void)
  194. {
  195.     void Ft_dlerror(char *str);
  196.     void Ft_dlmessage();
  197.  
  198.     /*******
  199.     dl_setmessage(dlmessage);
  200.     *********/
  201.     dl_seterror(Ft_dlerror);
  202.     return(0);
  203. }
  204.  
  205. void Ft_dlerror(char *str)
  206. {
  207.     fprintf(stderr, "Install: %s.\n", str);
  208.     Ft_catcher(ERRR);
  209. }
  210.  
  211. /***************
  212. void Ft_dlmessage(str)
  213. char *str;
  214. {
  215.     fputs("Install: Loading and linking modules...\n", stderr);
  216.     fputs(str, stderr);
  217. }
  218. ******************/
  219.